// PDF文本处理功能模块
class TextProcessingModule {
  constructor() {
    this.currentPdfText = '';
    this.selectedText = '';
    this.fixedPart = '';
    
    // 初始化AI服务
    this.aiService = new ZhipuAIService();
    this.configManager = new AIConfigManager();
    
    // 加载AI配置
    this.loadAIConfig();
    
    this.init();
  }

  // 加载AI配置
  loadAIConfig() {
    const config = this.configManager.getConfig();
    if (config.apiKey) {
      this.aiService.setApiKey(config.apiKey);
    }
    
    // 监听配置更新事件
    window.addEventListener('aiConfigUpdated', (event) => {
      const { apiKey, enabled } = event.detail;
      if (apiKey) {
        this.aiService.setApiKey(apiKey);
      }
      this.updateUIForAIStatus(enabled);
    });
  }

  // 更新UI以反映AI状态
  updateUIForAIStatus(enabled) {
    const generateBtn = document.getElementById('generate-text-regex-btn');
    const aiToggle = document.getElementById('ai-toggle-btn');
    
    if (generateBtn) {
      if (enabled) {
        generateBtn.textContent = '🤖 AI生成正则';
        generateBtn.title = '使用智谱AI生成正则表达式';
      } else {
        generateBtn.textContent = '生成正则表达式';
        generateBtn.title = '使用传统方法生成正则表达式';
      }
    }
    
    if (aiToggle) {
      aiToggle.textContent = enabled ? '🤖 AI模式' : '⚙️ 传统模式';
      aiToggle.className = enabled ? 'ai-toggle-btn ai-enabled' : 'ai-toggle-btn';
    }
  }

  init() {
    console.log('🔧 初始化文本处理器...');
    
    // 等待DOM完全加载
    if (document.readyState === 'loading') {
      console.log('⏳ DOM还在加载中，等待完成...');
      document.addEventListener('DOMContentLoaded', () => {
        console.log('✅ DOM加载完成，继续初始化...');
        this.initAfterDOMReady();
      });
    } else {
      console.log('✅ DOM已准备就绪，直接初始化...');
      this.initAfterDOMReady();
    }
  }
  
  initAfterDOMReady() {
    console.log('🚀 开始初始化组件...');
    this.bindEvents();
    this.setupDragAndDrop();
    
    // 检查页面元素
    const generatedRegexArea = document.getElementById('generated-regex');
    console.log('🔍 检查页面元素 #generated-regex:', generatedRegexArea);
    if (!generatedRegexArea) {
      console.error('❌ 页面缺少 #generated-regex 元素');
    } else {
      console.log('✅ 找到正则显示区域元素');
      console.log('📏 元素尺寸:', {
        width: generatedRegexArea.offsetWidth,
        height: generatedRegexArea.offsetHeight,
        visible: generatedRegexArea.offsetParent !== null
      });
    }
  }

  bindEvents() {
    const textPdfInput = document.getElementById('text-pdf-input');
    const generateTextRegexBtn = document.getElementById('generate-text-regex-btn');
    const copyRegexBtn = document.getElementById('copy-regex-btn');
    const selectFixedBtn = document.getElementById('select-fixed-btn');
    const clearFixedBtn = document.getElementById('clear-fixed-btn');
    const textReuploadBtn = document.getElementById('text-reupload-btn');
    const aiConfigBtn = document.getElementById('ai-config-btn');

    if (textPdfInput) {
      textPdfInput.addEventListener('change', (e) => this.handleFileSelect(e));
    }

    if (textReuploadBtn) {
      textReuploadBtn.addEventListener('click', () => this.handleReupload());
    }

    if (generateTextRegexBtn) {
      generateTextRegexBtn.addEventListener('click', () => this.generateRegexFromSelection());
    }

    if (copyRegexBtn) {
      copyRegexBtn.addEventListener('click', () => this.copyRegexToClipboard());
    }

    if (selectFixedBtn) {
      selectFixedBtn.addEventListener('click', () => this.selectFixedPartFromText());
    }

    if (clearFixedBtn) {
      clearFixedBtn.addEventListener('click', () => this.clearFixedPart());
    }

    // AI配置按钮事件
    if (aiConfigBtn) {
      aiConfigBtn.addEventListener('click', () => this.showAIConfig());
    }

    // 文本选择事件
    const pdfTextDisplay = document.getElementById('pdf-text-display');
    if (pdfTextDisplay) {
      pdfTextDisplay.addEventListener('mouseup', () => this.handleTextSelection());
      pdfTextDisplay.addEventListener('keyup', () => this.handleTextSelection());
    }

    // 第一步文本框的输入和选择事件
    const selectedTextArea = document.getElementById('selected-text');
    if (selectedTextArea) {
      selectedTextArea.addEventListener('input', (e) => {
        this.selectedText = e.target.value;
      });
      
      // 监听第一步文本框的选择事件，将选中内容自动填入第二步
      selectedTextArea.addEventListener('mouseup', () => this.handleStep1TextSelection());
      selectedTextArea.addEventListener('keyup', () => this.handleStep1TextSelection());
    }

    // 固定部分文本变化事件
    const fixedPartText = document.getElementById('fixed-part-text');
    if (fixedPartText) {
      fixedPartText.addEventListener('input', (e) => {
        this.fixedPart = e.target.value;
      });
      
      // 监听固定部分文本框的选择事件
      fixedPartText.addEventListener('mouseup', () => this.handleFixedPartSelection());
      fixedPartText.addEventListener('keyup', () => this.handleFixedPartSelection());
    }

    // 初始化UI状态
    this.updateUIForAIStatus(this.configManager.isEnabled());
  }

  // 切换AI模式
  toggleAIMode() {
    const currentEnabled = this.configManager.isEnabled();
    const newEnabled = !currentEnabled;
    
    if (newEnabled && !this.configManager.isConfigured()) {
      this.showMessage('请先配置智谱AI API密钥', 'warning');
      this.showAIConfig();
      return;
    }
    
    this.configManager.setEnabled(newEnabled);
    this.updateUIForAIStatus(newEnabled);
    
    const message = newEnabled ? '已切换到AI模式 🤖' : '已切换到传统模式 ⚙️';
    this.showMessage(message, 'success');
  }

  // 显示AI配置面板
  showAIConfig() {
    // 移除已存在的配置面板
    const existingPanel = document.querySelector('.ai-config-container');
    if (existingPanel) {
      existingPanel.remove();
    }

    // 创建配置面板
    const configContainer = this.configManager.createConfigUI();
    
    // 添加关闭按钮
    const closeBtn = document.createElement('button');
    closeBtn.textContent = '×';
    closeBtn.style.cssText = `
      position: absolute;
      top: 16px;
      right: 16px;
      background: none;
      border: none;
      font-size: 24px;
      cursor: pointer;
      color: #6b7280;
      width: 32px;
      height: 32px;
      display: flex;
      align-items: center;
      justify-content: center;
      border-radius: 50%;
    `;
    closeBtn.addEventListener('click', () => configContainer.remove());
    
    const panel = configContainer.querySelector('.ai-config-panel');
    panel.style.position = 'relative';
    panel.appendChild(closeBtn);

    // 点击遮罩层关闭
    configContainer.addEventListener('click', (e) => {
      if (e.target === configContainer) {
        configContainer.remove();
      }
    });

    // 添加到页面
    document.body.appendChild(configContainer);
  }

  setupDragAndDrop() {
    const textDropZone = document.getElementById('text-drop-zone');
    if (!textDropZone) return;

    ['dragover', 'dragleave', 'drop'].forEach(eventName => {
      textDropZone.addEventListener(eventName, (e) => {
        e.preventDefault();
        e.stopPropagation();
      });
    });

    textDropZone.addEventListener('dragover', () => {
      textDropZone.classList.add('dragover');
    });

    textDropZone.addEventListener('dragleave', () => {
      textDropZone.classList.remove('dragover');
    });

    textDropZone.addEventListener('drop', (e) => {
      textDropZone.classList.remove('dragover');
      const files = e.dataTransfer.files;
      if (files.length > 0 && files[0].type === 'application/pdf') {
        this.handleFileSelect({ target: { files: [files[0]] } });
      } else {
        this.showMessage('请拖拽PDF文件', 'warning');
      }
    });
  }

  handleFileSelect(event) {
    const file = event.target.files[0];
    if (!file) return;

    if (file.type !== 'application/pdf') {
      this.showMessage('请选择PDF文件', 'error');
      return;
    }

    // 显示重新上传按钮
    const textReuploadBtn = document.getElementById('text-reupload-btn');
    if (textReuploadBtn) {
      textReuploadBtn.style.display = 'inline-block';
    }

    // 更新UI显示选中的文件
    const textDropZone = document.getElementById('text-drop-zone');
    if (textDropZone) {
      textDropZone.innerHTML = `
        <div style="text-align: center;">
          <div style="margin-bottom: 10px; color: #28a745; font-weight: 500;">
            ✓ 正在处理文件...
          </div>
          <div style="font-size: 14px; color: #666;">
            ${file.name}
          </div>
        </div>
      `;
    }

    this.selectedFile = file;
    // 自动开始处理PDF
    this.processPdfText();
  }

  handleReupload() {
    // 清空当前文件
    this.selectedFile = null;
    
    // 清空文本显示区域
    const pdfTextDisplay = document.getElementById('pdf-text-display');
    if (pdfTextDisplay) {
      pdfTextDisplay.innerHTML = '';
    }
    
    // 重置拖拽区域
    const textDropZone = document.getElementById('text-drop-zone');
    if (textDropZone) {
      textDropZone.innerHTML = `
        <label for="text-pdf-input" class="upload-btn">Select or Drag PDF here</label>
        <input type="file" id="text-pdf-input" accept=".pdf" style="display: none;">
        <button id="text-reupload-btn" class="reupload-btn" style="display: none;">Re-upload PDF</button>
      `;
    }
    
    // 隐藏重新上传按钮
    const textReuploadBtn = document.getElementById('text-reupload-btn');
    if (textReuploadBtn) {
      textReuploadBtn.style.display = 'none';
    }
    
    // 清空文件输入框
    const textPdfInput = document.getElementById('text-pdf-input');
    if (textPdfInput) {
      textPdfInput.value = '';
    }
    
    // 重新绑定事件
    this.bindEvents();
    
    // 触发文件选择
    if (textPdfInput) {
      textPdfInput.click();
    }
  }

  async processPdfText() {
    if (!this.selectedFile) {
      this.showMessage('请先选择PDF文件', 'warning');
      return;
    }

    try {
      this.showMessage('正在处理PDF文件...', 'info');
      
      const reader = new FileReader();
      reader.onload = async (event) => {
        try {
          const pdfData = event.target.result;
          const fullText = await this.extractTextFromPdf(pdfData);
          this.displayExtractedText(fullText);
          this.showMessage('PDF文本提取完成', 'success');
        } catch (error) {
          console.error('PDF处理错误:', error);
          this.showMessage('PDF处理失败: ' + error.message, 'error');
        }
      };
      reader.readAsArrayBuffer(this.selectedFile);
    } catch (error) {
      console.error('处理PDF时出错:', error);
      this.showMessage('处理PDF时出错: ' + error.message, 'error');
    }
  }

  async extractTextFromPdf(pdfData) {
    if (!window.pdfjsLib) {
      throw new Error('PDF.js库未加载');
    }

    const loadingTask = pdfjsLib.getDocument({ data: pdfData });
    const pdf = await loadingTask.promise;
    
    let fullText = '';
    for (let i = 1; i <= pdf.numPages; i++) {
      const page = await pdf.getPage(i);
      const content = await page.getTextContent();
      fullText += content.items.map(item => item.str).join(' ');
      fullText += '\n'; // 页面间添加换行
    }

    return fullText;
  }

  displayExtractedText(text) {
    this.currentPdfText = text;
    const pdfTextDisplay = document.getElementById('pdf-text-display');
    if (pdfTextDisplay) {
      pdfTextDisplay.value = text;
      pdfTextDisplay.style.height = 'auto';
      pdfTextDisplay.style.height = Math.min(pdfTextDisplay.scrollHeight, 400) + 'px';
    }

    // 清空之前的选择
    this.clearSelection();
  }

  handleTextSelection() {
    const pdfTextDisplay = document.getElementById('pdf-text-display');
    const textSelectionInfo = document.getElementById('text-selection-info');
    const selectedTextArea = document.getElementById('selected-text');

    if (!pdfTextDisplay) return;

    const selectedText = pdfTextDisplay.value.substring(
      pdfTextDisplay.selectionStart,
      pdfTextDisplay.selectionEnd
    );

    if (selectedText.length > 0) {
      // 保留原始选中文本，不使用trim()
      this.selectedText = selectedText;
      
      // 更新选择信息显示
      if (textSelectionInfo) {
        textSelectionInfo.innerHTML = `
          <span style="color: #28a745; font-weight: 500;">
            已选择 ${selectedText.length} 个字符: "${selectedText.substring(0, 50)}${selectedText.length > 50 ? '...' : ''}"
          </span>
        `;
      }

      // 更新选中文本区域
      if (selectedTextArea) {
        selectedTextArea.value = this.selectedText;
      }
    } else {
      this.clearSelection();
    }
  }

  // 处理第一步文本框的选择事件
  handleStep1TextSelection() {
    const selectedTextArea = document.getElementById('selected-text');
    const fixedPartText = document.getElementById('fixed-part-text');

    if (!selectedTextArea || !fixedPartText) return;

    const selectedText = selectedTextArea.value.substring(
      selectedTextArea.selectionStart,
      selectedTextArea.selectionEnd
    );

    if (selectedText.length > 0) {
      // 保留原始选中文本，不使用trim()
      fixedPartText.value = selectedText;
      this.fixedPart = selectedText;
      
      // 显示提示信息
      this.showMessage(`已将选中内容 "${selectedText}" 设置为固定部分`, 'success');
    }
  }

  clearSelection() {
    this.selectedText = '';
    const textSelectionInfo = document.getElementById('text-selection-info');
    const selectedTextArea = document.getElementById('selected-text');
    const generatedRegexArea = document.getElementById('generated-regex');

    if (textSelectionInfo) {
      textSelectionInfo.innerHTML = '<span>选中文本将显示在这里</span>';
    }

    if (selectedTextArea) {
      selectedTextArea.value = '';
    }

    if (generatedRegexArea) {
      generatedRegexArea.value = '';
    }
  }

  generateRegexFromSelection() {
    if (!this.selectedText.trim()) {
      this.showMessage('请先在文本区域选择需要生成正则的文本', 'warning');
      return;
    }

    // 检查是否启用AI模式
    const isAIEnabled = this.configManager.isEnabled();
    
    if (isAIEnabled) {
      this.generateRegexWithAI();
    } else {
      this.generateRegexTraditional();
    }
  }

  // 使用AI生成正则表达式
  async generateRegexWithAI() {
    console.log('🚀 开始AI正则生成流程...');
    console.log('选中文本:', this.selectedText);
    console.log('固定部分:', this.fixedPart);
    
    if (!this.selectedText || !this.selectedText.trim()) {
      console.error('❌ 没有选中文本');
      this.showMessage('请先选择要生成正则表达式的文本', 'error');
      return;
    }

    if (!this.aiService.getApiStatus()) {
      console.error('❌ AI服务未配置');
      this.showMessage('请先配置智谱AI API密钥', 'error');
      return;
    }

    try {
      const generateBtn = document.getElementById('generate-text-regex-btn');
      generateBtn.textContent = '🤖 生成中...';
      generateBtn.disabled = true;
      console.log('🔄 按钮状态已更新为生成中...');

      console.log('📞 调用AI服务生成正则...');
      const regexPattern = await this.aiService.generateRegex(
        this.selectedText, 
        this.fixedPart
      );

      console.log('🎯 获得AI生成的正则:', regexPattern);
      
      const generatedRegexArea = document.getElementById('generated-regex');
      console.log('🔍 查找显示区域元素:', generatedRegexArea);
      
      if (generatedRegexArea) {
        generatedRegexArea.value = regexPattern;
        console.log('✅ AI生成的正则表达式已设置到显示区域');
        console.log('📝 当前显示区域的值:', generatedRegexArea.value);
        
        // 强制触发界面更新
        generatedRegexArea.dispatchEvent(new Event('input'));
        generatedRegexArea.dispatchEvent(new Event('change'));
        
      } else {
        console.error('❌ 未找到正则表达式显示区域元素 #generated-regex');
      }

      // 测试生成的正则表达式
      console.log('🧪 测试生成的正则表达式...');
      const isValid = this.aiService.testRegex(regexPattern, this.selectedText);
      console.log('🔬 正则测试结果:', isValid);
      
      if (isValid) {
        this.showMessage('🎉 AI正则表达式生成成功！已验证匹配原文本', 'success');
      } else {
        this.showMessage('⚠️ AI正则表达式生成完成，但可能需要手动调整', 'warning');
      }

      // 确保文本框可见并滚动到视图中
      if (generatedRegexArea) {
        console.log('📍 滚动到显示区域...');
        generatedRegexArea.scrollIntoView({ behavior: 'smooth', block: 'center' });
        generatedRegexArea.focus();
        
        // 添加高亮效果
        generatedRegexArea.style.backgroundColor = '#dcfce7';
        setTimeout(() => {
          generatedRegexArea.style.backgroundColor = '#f9fafb';
        }, 2000);
      }

    } catch (error) {
      console.error('💥 AI生成正则表达式失败:', error);
      this.showMessage(`AI没有回答: ${error.message}`, 'error');
      
      // 清空显示区域
      const generatedRegexArea = document.getElementById('generated-regex');
      if (generatedRegexArea) {
        generatedRegexArea.value = '';
      }
      
    } finally {
      // 恢复按钮状态
      const generateBtn = document.getElementById('generate-text-regex-btn');
      generateBtn.textContent = '🤖 AI生成正则';
      generateBtn.disabled = false;
      console.log('🔄 按钮状态已恢复');
    }
  }

  // 使用传统方法生成正则表达式
  generateRegexTraditional() {
    try {
      let regexPattern;
      
      // 如果有固定部分，使用新的逻辑
      if (this.fixedPart.trim()) {
        regexPattern = this.createRegexWithFixedPart(this.selectedText, this.fixedPart);
      } else {
        // 使用原有的智能正则生成逻辑
        regexPattern = this.createRegexPattern(this.selectedText);
      }

      const generatedRegexArea = document.getElementById('generated-regex');
      if (generatedRegexArea) {
        generatedRegexArea.value = regexPattern;
        console.log('传统方法生成的正则表达式已显示:', regexPattern);
        
        // 确保文本框可见并滚动到视图中
        generatedRegexArea.scrollIntoView({ behavior: 'smooth', block: 'center' });
        generatedRegexArea.focus();
      } else {
        console.error('未找到正则表达式显示区域元素');
      }

      this.showMessage('正则表达式生成成功！', 'success');
    } catch (error) {
      console.error('生成正则表达式时出错:', error);
      this.showMessage('生成正则表达式失败，请检查选中的文本', 'error');
    }
  }

  // 新增：基于固定部分生成正则的方法
  createRegexWithFixedPart(selectedText, fixedPart) {
    // 确保固定部分在选中文本中
    if (!selectedText.includes(fixedPart)) {
      throw new Error('固定部分不在选中文本中');
    }

    // 转义固定部分中的特殊字符
    const escapedFixedPart = this.escapeRegexChars(fixedPart);
    
    // 找到固定部分在选中文本中的位置
    const fixedPartIndex = selectedText.indexOf(fixedPart);
    
    // 分割文本：前缀 + 固定部分 + 后缀
    const prefix = selectedText.substring(0, fixedPartIndex);
    const suffix = selectedText.substring(fixedPartIndex + fixedPart.length);
    
    // 构建正则表达式
    let regexParts = [];
    
    // 处理前缀部分（可变）
    if (prefix) {
      const prefixPattern = this.createVariablePattern(prefix);
      regexParts.push(`(${prefixPattern})`);
    }
    
    // 添加固定部分（保持不变）
    regexParts.push(escapedFixedPart);
    
    // 处理后缀部分（可变）
    if (suffix) {
      const suffixPattern = this.createVariablePattern(suffix);
      regexParts.push(`(${suffixPattern})`);
    }
    
    return regexParts.join('');
  }

  // 新增：为可变部分创建模式
  createVariablePattern(text) {
    // 分析文本特征并生成相应的正则模式
    const patterns = [
      // 数字模式
      { regex: /^\d+$/, replacement: '\\d+' },
      // 字母模式
      { regex: /^[a-zA-Z]+$/, replacement: '[a-zA-Z]+' },
      // 字母数字模式
      { regex: /^[a-zA-Z0-9]+$/, replacement: '[a-zA-Z0-9]+' },
      // 日期模式 (YYYY-MM-DD, YYYY/MM/DD, DD-MM-YYYY等)
      { regex: /^\d{4}[-\/]\d{1,2}[-\/]\d{1,2}$/, replacement: '\\d{4}[-\\/]\\d{1,2}[-\\/]\\d{1,2}' },
      { regex: /^\d{1,2}[-\/]\d{1,2}[-\/]\d{4}$/, replacement: '\\d{1,2}[-\\/]\\d{1,2}[-\\/]\\d{4}' },
      // 时间模式
      { regex: /^\d{1,2}:\d{2}(:\d{2})?$/, replacement: '\\d{1,2}:\\d{2}(:\\d{2})?' },
      // 邮箱模式
      { regex: /^[^\s@]+@[^\s@]+\.[^\s@]+$/, replacement: '[^\\s@]+@[^\\s@]+\\.[^\\s@]+' },
      // 电话号码模式
      { regex: /^[\d\-\(\)\s\+]+$/, replacement: '[\\d\\-\\(\\)\\s\\+]+' },
      // 中文字符模式
      { regex: /^[\u4e00-\u9fa5]+$/, replacement: '[\\u4e00-\\u9fa5]+' },
      // 混合中英文模式
      { regex: /^[\u4e00-\u9fa5a-zA-Z\s]+$/, replacement: '[\\u4e00-\\u9fa5a-zA-Z\\s]+' }
    ];

    // 尝试匹配已知模式
    for (const pattern of patterns) {
      if (pattern.regex.test(text)) {
        return pattern.replacement;
      }
    }

    // 如果没有匹配的模式，创建通用模式
    return this.createGenericPattern(text);
  }

  // 新增：创建通用模式
  createGenericPattern(text) {
    // 分析文本中的字符类型
    const hasDigits = /\d/.test(text);
    const hasLetters = /[a-zA-Z]/.test(text);
    const hasChinese = /[\u4e00-\u9fa5]/.test(text);
    const hasSpecialChars = /[^\w\u4e00-\u9fa5\s]/.test(text);

    let charClass = '';
    
    if (hasDigits) charClass += '\\d';
    if (hasLetters) charClass += 'a-zA-Z';
    if (hasChinese) charClass += '\\u4e00-\\u9fa5';
    if (hasSpecialChars) {
      // 转义特殊字符
      const specialChars = text.match(/[^\w\u4e00-\u9fa5\s]/g);
      if (specialChars) {
        const escapedSpecials = [...new Set(specialChars)].map(char => 
          this.escapeRegexChars(char)
        ).join('');
        charClass += escapedSpecials;
      }
    }
    
    // 如果包含空格，添加空格
    if (/\s/.test(text)) {
      charClass += '\\s';
    }

    return charClass ? `[${charClass}]+` : '.+';
  }

  // 新增：处理固定部分文本框选择的方法
  handleFixedPartSelection() {
    const fixedPartTextArea = document.getElementById('fixed-part-text');
    if (!fixedPartTextArea) return;

    const selectedText = fixedPartTextArea.value.substring(
      fixedPartTextArea.selectionStart,
      fixedPartTextArea.selectionEnd
    );

    if (selectedText.length > 0) {
      // 保留原始选中文本，不使用trim()
      this.fixedPart = selectedText;
      this.showMessage(`已选择固定部分: "${selectedText.length > 30 ? selectedText.substring(0, 30) + '...' : selectedText}"`, 'success');
    }
  }

  // 新增：选择固定部分的方法
  selectFixedPartFromText() {
    if (!this.selectedText.trim()) {
      this.showMessage('请先选择完整的文本内容', 'warning');
      return;
    }

    // 获取用户在固定部分文本框中的选择
    const fixedPartTextArea = document.getElementById('fixed-part-text');
    if (!fixedPartTextArea) return;

    // 将选中的文本填入固定部分文本框
    fixedPartTextArea.value = this.selectedText;
    
    // 提示用户进行下一步操作
    this.showMessage('文本已填入固定部分框，请选择需要保持不变的部分或直接手动编辑', 'info');
    
    // 聚焦到固定部分文本框并全选文本，方便用户进行选择
    fixedPartTextArea.focus();
    fixedPartTextArea.select();
  }

  // 新增：清除固定部分的方法
  clearFixedPart() {
    this.fixedPart = '';
    const fixedPartTextArea = document.getElementById('fixed-part-text');
    if (fixedPartTextArea) {
      fixedPartTextArea.value = '';
    }
    this.showMessage('已清除固定部分', 'info');
  }

  // 新增：转义正则表达式特殊字符的方法
  escapeRegexChars(text) {
    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
  }

  createRegexPattern(text) {
    // 转义特殊字符
    let escaped = text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
    
    // 定义替换模式，从具体到通用
    const patterns = [
      // 报告编号模式 (如: EFHZ23050362-CG-01)
      { pattern: /([A-Z]+)\d+([A-Z]+-\d+)/g, replacement: '([A-Z]+\\d+[A-Z]+-\\d+)' },
      { pattern: /([A-Z]+)\d+([A-Z]+)/g, replacement: '([A-Z]+\\d+[A-Z]+)' },
      
      // 日期模式
      { pattern: /\d{1,2}\/\d{1,2}\/\d{4}/g, replacement: '(\\d{1,2}\\/\\d{1,2}\\/\\d{4})' },
      { pattern: /\d{2}\.\d{2},\s*\d{4}/g, replacement: '(\\d{2}\\.\\d{2},\\s*\\d{4})' },
      { pattern: /[A-Z]{3}\.?\s*\d{1,2},\s*\d{4}/g, replacement: '([A-Z]{3}\\.?\\s*\\d{1,2},\\s*\\d{4})' },
      
      // 电子邮件模式
      { pattern: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, replacement: '([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,})' },
      
      // 电话号码模式
      { pattern: /\+?\d{1,3}[-.\s]?\(?\d{1,4}\)?[-.\s]?\d{1,4}[-.\s]?\d{1,9}/g, replacement: '(\\+?\\d{1,3}[-\\.\\s]?\\(?\\d{1,4}\\)?[-\\.\\s]?\\d{1,4}[-\\.\\s]?\\d{1,9})' },
      
      // 通用数字模式
      { pattern: /\d+/g, replacement: '\\d+' },
      
      // 字母模式
      { pattern: /[A-Z]+/g, replacement: '[A-Z]+' },
      { pattern: /[a-z]+/g, replacement: '[a-z]+' },
      
      // 空格模式
      { pattern: /\s+/g, replacement: '\\s+' }
    ];
    
    // 应用模式替换
    patterns.forEach(({ pattern, replacement }) => {
      escaped = escaped.replace(pattern, replacement);
    });
    
    // 返回带捕获组的正则表达式
    return `/${escaped}/i`;
  }

  async copyRegexToClipboard() {
    const generatedRegexArea = document.getElementById('generated-regex');
    if (!generatedRegexArea || !generatedRegexArea.value.trim()) {
      this.showMessage('没有可复制的正则表达式', 'warning');
      return;
    }

    try {
      await navigator.clipboard.writeText(generatedRegexArea.value);
      this.showMessage('正则表达式已复制到剪贴板', 'success');
    } catch (error) {
      // 降级方案：使用传统的复制方法
      try {
        generatedRegexArea.select();
        document.execCommand('copy');
        this.showMessage('正则表达式已复制到剪贴板', 'success');
      } catch (fallbackError) {
        console.error('复制失败:', fallbackError);
        this.showMessage('复制失败，请手动复制', 'error');
      }
    }
  }

  showMessage(message, type = 'info') {
    if (window.ElMessage) {
      window.ElMessage[type](message);
    } else {
      console.log(`[${type.toUpperCase()}] ${message}`);
    }
  }
}

// 当DOM加载完成后初始化模块
document.addEventListener('DOMContentLoaded', () => {
  // 确保在tab切换功能初始化后再初始化文本处理模块
  setTimeout(() => {
    window.textProcessingModule = new TextProcessingModule();
  }, 100);
});

// 导出模块供其他地方使用
window.TextProcessingModule = TextProcessingModule;